{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0b9781df",
   "metadata": {},
   "source": [
    "# TokenTextSplitter\n",
    "\n",
    "언어 모델에는 토큰 제한이 있습니다. 따라서 토큰 제한을 초과하지 않아야 합니다.\n",
    "\n",
    "`TokenTextSplitter` 는 텍스트를 토큰 수를 기반으로 청크를 생성할 때 유용합니다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5299ad02",
   "metadata": {},
   "source": [
    "## tiktoken\n",
    "\n",
    "`tiktoken` 은 OpenAI에서 만든 빠른 `BPE Tokenizer` 입니다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e365c78f",
   "metadata": {},
   "source": [
    "- `./data/appendix-keywords.txt` 파일을 열어 내용을 읽어들입니다.\n",
    "- 읽어들인 내용을 `file` 변수에 저장합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8919094",
   "metadata": {},
   "outputs": [],
   "source": [
    "# data/appendix-keywords.txt 파일을 열어서 f라는 파일 객체를 생성합니다.\n",
    "with open(\"./data/appendix-keywords.txt\") as f:\n",
    "    file = f.read()  # 파일의 내용을 읽어서 file 변수에 저장합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd16d938",
   "metadata": {},
   "source": [
    "파일로부터 읽은 파일의 일부 내용을 출력합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4bfdb81",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 파일으로부터 읽은 내용을 일부 출력합니다.\n",
    "print(file[:500])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b68155bf",
   "metadata": {},
   "source": [
    "`CharacterTextSplitter`를 사용하여 텍스트를 분할합니다.\n",
    "\n",
    "- `from_tiktoken_encoder` 메서드를 사용하여 Tiktoken 인코더 기반의 텍스트 분할기를 초기화합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe585376",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain_text_splitters import CharacterTextSplitter\n",
    "\n",
    "text_splitter = CharacterTextSplitter.from_tiktoken_encoder(\n",
    "    # 청크 크기를 300으로 설정합니다.\n",
    "    chunk_size=300,\n",
    "    # 청크 간 중복되는 부분이 없도록 설정합니다.\n",
    "    chunk_overlap=0,\n",
    ")\n",
    "# file 텍스트를 청크 단위로 분할합니다.\n",
    "texts = text_splitter.split_text(file)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8815d8e",
   "metadata": {},
   "source": [
    "분할된 청크의 개수를 출력합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d531f7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(texts))  # 분할된 청크의 개수를 출력합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2103054d",
   "metadata": {},
   "source": [
    "texts 리스트의 첫 번째 요소를 출력합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4edccf3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# texts 리스트의 첫 번째 요소를 출력합니다.\n",
    "print(texts[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a34aaa8b",
   "metadata": {},
   "source": [
    "**참고**\n",
    "\n",
    "- `CharacterTextSplitter.from_tiktoken_encoder`를 사용하는 경우, 텍스트는 `CharacterTextSplitter`에 의해서만 분할되고 `tiktoken` 토크나이저는 분할된 텍스트를 병합하는 데 사용됩니다. (이는 분할된 텍스트가 `tiktoken` 토크나이저로 측정한 청크 크기보다 클 수 있음을 의미합니다.)\n",
    "\n",
    "- `RecursiveCharacterTextSplitter.from_tiktoken_encoder`를 사용하면 분할된 텍스트가 언어 모델에서 허용하는 토큰의 청크 크기보다 크지 않도록 할 수 있으며, 각 분할은 크기가 더 큰 경우 재귀적으로 분할됩니다. 또한 tiktoken 분할기를 직접 로드할 수 있으며, 이는 각 분할이 청크 크기보다 작음을 보장합니다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83ce2732",
   "metadata": {},
   "source": [
    "## TokenTextSplitter\n",
    "\n",
    "- `TokenTextSplitter` 클래스를 사용하여 텍스트를 토큰 단위로 분할합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a3ab133",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain_text_splitters import TokenTextSplitter\n",
    "\n",
    "text_splitter = TokenTextSplitter(\n",
    "    chunk_size=300,  # 청크 크기를 10으로 설정합니다.\n",
    "    chunk_overlap=0,  # 청크 간 중복을 0으로 설정합니다.\n",
    ")\n",
    "\n",
    "# state_of_the_union 텍스트를 청크로 분할합니다.\n",
    "texts = text_splitter.split_text(file)\n",
    "print(texts[0])  # 분할된 텍스트의 첫 번째 청크를 출력합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78b017ab",
   "metadata": {},
   "source": [
    "## spaCy\n",
    "\n",
    "spaCy는 Python과 Cython 프로그래밍 언어로 작성된 고급 자연어 처리를 위한 오픈 소스 소프트웨어 라이브러리입니다.\n",
    "\n",
    "NLTK의 또 다른 대안은 spaCy tokenizer를 사용하는 것입니다.\n",
    "\n",
    "1. 텍스트가 분할되는 방식: **spaCy tokenizer**에 의해 분할됩니다.\n",
    "\n",
    "2. chunk size가 측정되는 방법: **문자 수**로 측정됩니다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6613e215",
   "metadata": {},
   "source": [
    "spaCy 라이브러리를 최신 버전으로 업그레이드하는 pip 명령어입니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33f71a93",
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install -qU spacy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7b7bb1e",
   "metadata": {},
   "source": [
    "`en_core_web_sm` 모델을 다운로드합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd2d49aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "!python -m spacy download en_core_web_sm --quiet"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "654384df",
   "metadata": {},
   "source": [
    "- `appendix-keywords.txt` 파일을 열어 내용을 읽어들입니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a04bd005",
   "metadata": {},
   "outputs": [],
   "source": [
    "# data/appendix-keywords.txt 파일을 열어서 f라는 파일 객체를 생성합니다.\n",
    "with open(\"./data/appendix-keywords.txt\") as f:\n",
    "    file = f.read()  # 파일의 내용을 읽어서 file 변수에 저장합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b4faf39",
   "metadata": {},
   "source": [
    "일부 내용을 출력하여 확인합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92e53e9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 파일으로부터 읽은 내용을 일부 출력합니다.\n",
    "print(file[:350])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e20652a",
   "metadata": {},
   "source": [
    "- `SpacyTextSplitter` 클래스를 사용하여 텍스트 분할기를 생성합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a9c4e8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "from langchain_text_splitters import SpacyTextSplitter\n",
    "\n",
    "# 경고 메시지를 무시합니다.\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "# SpacyTextSplitter를 생성합니다.\n",
    "text_splitter = SpacyTextSplitter(\n",
    "    chunk_size=200,  # 청크 크기를 200으로 설정합니다.\n",
    "    chunk_overlap=50,  # 청크 간 중복을 50으로 설정합니다.\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "928dfbcd",
   "metadata": {},
   "source": [
    "- `text_splitter` 객체의 `split_text` 메서드를 사용하여 `file` 텍스트를 분할합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c7f1e84d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# text_splitter를 사용하여 file 텍스트를 분할합니다.\n",
    "texts = text_splitter.split_text(file)\n",
    "print(texts[0])  # 분할된 텍스트의 첫 번째 요소를 출력합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8585c693",
   "metadata": {},
   "source": [
    "## SentenceTransformers\n",
    "\n",
    "`SentenceTransformersTokenTextSplitter`는 `sentence-transformer` 모델에 특화된 텍스트 분할기입니다.\n",
    "\n",
    "기본 동작은 사용하고자 하는 sentence transformer 모델의 토큰 윈도우에 맞게 텍스트를 청크로 분할하는 것입니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31c098ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain_text_splitters import SentenceTransformersTokenTextSplitter\n",
    "\n",
    "# 문장 분할기를 생성하고 청크 간 중복을 0으로 설정합니다.\n",
    "splitter = SentenceTransformersTokenTextSplitter(chunk_size=200, chunk_overlap=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54516251",
   "metadata": {},
   "source": [
    "샘플 텍스트를 확인합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16083e38",
   "metadata": {},
   "outputs": [],
   "source": [
    "# data/appendix-keywords.txt 파일을 열어서 f라는 파일 객체를 생성합니다.\n",
    "with open(\"./data/appendix-keywords.txt\") as f:\n",
    "    file = f.read()  # 파일의 내용을 읽어서 file 변수에 저장합니다.\n",
    "\n",
    "# 파일으로부터 읽은 내용을 일부 출력합니다.\n",
    "print(file[:350])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6563a98e",
   "metadata": {},
   "source": [
    "다음은 `file` 변수에 담긴 텍스트의 토큰의 개수를 세는 코드입니다. 시작과 종료 토큰의 개수를 제외한 후 출력합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c34c06da",
   "metadata": {},
   "outputs": [],
   "source": [
    "count_start_and_stop_tokens = 2  # 시작과 종료 토큰의 개수를 2로 설정합니다.\n",
    "\n",
    "# 텍스트의 토큰 개수에서 시작과 종료 토큰의 개수를 뺍니다.\n",
    "text_token_count = splitter.count_tokens(text=file) - count_start_and_stop_tokens\n",
    "print(text_token_count)  # 계산된 텍스트 토큰 개수를 출력합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0691dd26",
   "metadata": {},
   "source": [
    "`splitter.split_text()` 함수를 사용하여 `text_to_split` 변수에 저장된 텍스트를 청크(chunk) 단위로 분할합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9bc9c85",
   "metadata": {},
   "outputs": [],
   "source": [
    "text_chunks = splitter.split_text(text=file)  # 텍스트를 청크로 분할합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53a5f73e",
   "metadata": {},
   "source": [
    "첫 번째 청크를 출력하여 내용을 확인합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb6548ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 0번째 청크를 출력합니다.\n",
    "print(text_chunks[1])  # 분할된 텍스트 청크 중 두 번째 청크를 출력합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb97dd30",
   "metadata": {},
   "source": [
    "## NLTK\n",
    "\n",
    "Natural Language Toolkit (NLTK)은 Python 프로그래밍 언어로 작성된 영어 자연어 처리(NLP)를 위한 라이브러리와 프로그램 모음입니다.\n",
    "\n",
    "단순히 \"\\n\\n\"으로 분할하는 대신, NLTK tokenizers를 기반으로 텍스트를 분할하는 데 NLTK를 사용할 수 있습니다.\n",
    "\n",
    "1. 텍스트 분할 방법: NLTK tokenizer에 의해 분할됩니다.\n",
    "2. chunk 크기 측정 방법: 문자 수에 의해 측정됩니다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52d4ab36",
   "metadata": {},
   "source": [
    "- `nltk` 라이브러리를 설치하는 pip 명령어입니다.\n",
    "- NLTK(Natural Language Toolkit)는 자연어 처리를 위한 파이썬 라이브러리입니다.\n",
    "- 텍스트 데이터의 전처리, 토큰화, 형태소 분석, 품사 태깅 등 다양한 NLP 작업을 수행할 수 있습니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16e11572",
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install -qU nltk"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb7f61343cb52923",
   "metadata": {},
   "source": [
    "NLTK는 기본 설치 시 모든 데이터를 포함하지 않습니다. 이는 초기 설치 크기를 줄이고, 사용자가 필요한 데이터만 선택적으로 다운로드할 수 있게 합니다. \n",
    "NLTK에서 사용할 데이터를 다운로드 받습니다. 다운로드는 \"~/nltk_data\"에 설치됩니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "478ad71020b825e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "import nltk\n",
    "nltk.download('punkt')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fccf971",
   "metadata": {},
   "source": [
    "샘플 텍스트를 확인합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2291b93a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# data/appendix-keywords.txt 파일을 열어서 f라는 파일 객체를 생성합니다.\n",
    "with open(\"./data/appendix-keywords.txt\") as f:\n",
    "    file = f.read()  # 파일의 내용을 읽어서 file 변수에 저장합니다.\n",
    "\n",
    "# 파일으로부터 읽은 내용을 일부 출력합니다.\n",
    "print(file[:350])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45668c01",
   "metadata": {},
   "source": [
    "`NLTKTextSplitter` 클래스를 사용하여 텍스트 분할기를 생성합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "402d1fd6",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain_text_splitters import NLTKTextSplitter\n",
    "\n",
    "text_splitter = NLTKTextSplitter(\n",
    "    chunk_size=200,  # 청크 크기를 200으로 설정합니다.\n",
    "    chunk_overlap=0,  # 청크 간 중복을 0으로 설정합니다.\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fb83e21",
   "metadata": {},
   "source": [
    "`text_splitter` 객체의 `split_text` 메서드를 사용하여 `file` 텍스트를 분할합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b86af73c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# text_splitter를 사용하여 file 텍스트를 분할합니다.\n",
    "texts = text_splitter.split_text(file)\n",
    "print(texts[0])  # 분할된 텍스트의 첫 번째 요소를 출력합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb6be336",
   "metadata": {},
   "source": [
    "## KoNLPy\n",
    "\n",
    "KoNLPy(Korean NLP in Python)는 한국어 자연어 처리(NLP)를 위한 파이썬 패키지입니다.\n",
    "\n",
    "토큰 분할은 텍스트를 토큰이라고 하는 더 작고 관리하기 쉬운 단위로 분할하는 과정을 포함합니다.\n",
    "\n",
    "이러한 토큰은 종종 단어, 구, 기호 또는 추가 처리 및 분석에 중요한 다른 의미 있는 요소입니다.\n",
    "\n",
    "영어와 같은 언어에서 토큰 분할은 일반적으로 공백과 구두점으로 단어를 분리하는 것을 포함합니다.\n",
    "\n",
    "토큰 분할의 효과는 언어 구조에 대한 토크나이저의 이해에 크게 의존하며, 이는 의미 있는 토큰 생성을 보장합니다.\n",
    "\n",
    "영어를 위해 설계된 토크나이저는 한국어와 같은 다른 언어의 고유한 의미 구조를 이해할 수 있는 능력이 없기 때문에 한국어 처리에 효과적으로 사용될 수 없습니다.\n",
    "\n",
    "### KoNLPy의 Kkma 분석기를 사용한 한국어 토큰 분할\n",
    "\n",
    "한국어 텍스트의 경우 KoNLPY에는 `Kkma`(Korean Knowledge Morpheme Analyzer)라는 형태소 분석기가 포함되어 있습니다.\n",
    "\n",
    "`Kkma`는 한국어 텍스트에 대한 상세한 형태소 분석을 제공합니다.\n",
    "\n",
    "문장을 단어로, 단어를 각각의 형태소로 분해하고 각 토큰에 대한 품사를 식별합니다.\n",
    "\n",
    "텍스트 블록을 개별 문장으로 분할할 수 있어 긴 텍스트 처리에 특히 유용합니다.\n",
    "\n",
    "### 사용시 고려사항\n",
    "\n",
    "`Kkma`는 상세한 분석으로 유명하지만, 이러한 정밀성이 처리 속도에 영향을 미칠 수 있다는 점에 유의해야 합니다. 따라서 `Kkma`는 신속한 텍스트 처리보다 분석적 깊이가 우선시되는 애플리케이션에 가장 적합합니다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3d535db",
   "metadata": {},
   "source": [
    "- KoNLPy 라이브러리를 설치하는 pip 명령어입니다.\n",
    "- KoNLPy는 한국어 자연어 처리를 위한 파이썬 패키지로, 형태소 분석, 품사 태깅, 구문 분석 등의 기능을 제공합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fef21f2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install -qU konlpy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1421b1fc",
   "metadata": {},
   "source": [
    "샘플 텍스트를 확인합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "854203b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# data/appendix-keywords.txt 파일을 열어서 f라는 파일 객체를 생성합니다.\n",
    "with open(\"./data/appendix-keywords.txt\") as f:\n",
    "    file = f.read()  # 파일의 내용을 읽어서 file 변수에 저장합니다.\n",
    "\n",
    "# 파일으로부터 읽은 내용을 일부 출력합니다.\n",
    "print(file[:350])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d03c3713",
   "metadata": {},
   "source": [
    "KonlpyTextSplitter를 사용하여 한국어 텍스트를 분할하는 예제입니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ef8d062",
   "metadata": {},
   "outputs": [],
   "source": [
    "import chunk\n",
    "from langchain_text_splitters import KonlpyTextSplitter\n",
    "\n",
    "# KonlpyTextSplitter를 사용하여 텍스트 분할기 객체를 생성합니다.\n",
    "text_splitter = KonlpyTextSplitter(chunk_size=200, chunk_overlap=50)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbb7c0ab",
   "metadata": {},
   "source": [
    "`text_splitter`를 사용하여 `file`를 문장 단위로 분할합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c5e3c29",
   "metadata": {},
   "outputs": [],
   "source": [
    "texts = text_splitter.split_text(file)  # 한국어 문서를 문장 단위로 분할합니다.\n",
    "print(texts[0])  # 분할된 문장 중 첫 번째 문장을 출력합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "481f3ae9",
   "metadata": {},
   "source": [
    "## Hugging Face tokenizer\n",
    "\n",
    "Hugging Face는 다양한 토크나이저를 제공합니다.\n",
    "\n",
    "이 코드에서는 Hugging Face의 토크나이저 중 하나인 GPT2TokenizerFast를 사용하여 텍스트의 토큰 길이를 계산합니다.\n",
    "\n",
    "텍스트 분할 방식은 다음과 같습니다:\n",
    "\n",
    "- 전달된 문자 단위로 분할됩니다.\n",
    "\n",
    "청크 크기 측정 방식은 다음과 같습니다:\n",
    "\n",
    "- Hugging Face 토크나이저에 의해 계산된 토큰 수를 기준으로 합니다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1f1ec50",
   "metadata": {},
   "source": [
    "- `GPT2TokenizerFast` 클래스를 사용하여 `tokenizer` 객체를 생성합니다.\n",
    "- `from_pretrained` 메서드를 호출하여 사전 학습된 \"gpt2\" 토크나이저 모델을 로드합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74a7b2ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "from transformers import GPT2TokenizerFast\n",
    "\n",
    "# GPT-2 모델의 토크나이저를 불러옵니다.\n",
    "hf_tokenizer = GPT2TokenizerFast.from_pretrained(\"gpt2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "343ee3ed",
   "metadata": {},
   "source": [
    "샘플 텍스트를 확인합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd437637",
   "metadata": {},
   "outputs": [],
   "source": [
    "# data/appendix-keywords.txt 파일을 열어서 f라는 파일 객체를 생성합니다.\n",
    "with open(\"./data/appendix-keywords.txt\") as f:\n",
    "    file = f.read()  # 파일의 내용을 읽어서 file 변수에 저장합니다.\n",
    "\n",
    "# 파일으로부터 읽은 내용을 일부 출력합니다.\n",
    "print(file[:350])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d87e41c",
   "metadata": {},
   "source": [
    "`from_huggingface_tokenizer` 메서드를 통해 허깅페이스 토크나이저(`tokenizer`)를 사용하여 텍스트 분할기를 초기화합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a5f9bd4",
   "metadata": {},
   "outputs": [],
   "source": [
    "text_splitter = CharacterTextSplitter.from_huggingface_tokenizer(\n",
    "    # 허깅페이스 토크나이저를 사용하여 CharacterTextSplitter 객체를 생성합니다.\n",
    "    hf_tokenizer,\n",
    "    chunk_size=300,\n",
    "    chunk_overlap=50,\n",
    ")\n",
    "# state_of_the_union 텍스트를 분할하여 texts 변수에 저장합니다.\n",
    "texts = text_splitter.split_text(file)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d46ef64",
   "metadata": {},
   "source": [
    "1 번째 요소의 분할 결과를 확인합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "404f85ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(texts[1])  # texts 리스트의 1 번째 요소를 출력합니다."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py-test",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
